home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 2000 November: Tool Chest / Dev.CD Nov 00 TC Disk 2.toast / pc / sample code / quicktime / music and sound / qtmusic / application files / comapplication.c next >
Encoding:
Text File  |  2000-09-28  |  11.1 KB  |  452 lines
  1. //////////
  2. //
  3. //    File:        ComApplication.c
  4. //
  5. //    Contains:    Application-specific code for QuickTime Music Architecture sample.
  6. //                This file is used for BOTH MacOS and Windows.
  7. //
  8. //    Written by:    Tim Monroe
  9. //                Based (heavily!) on the MovieShell code written by Apple DTS.
  10. //
  11. //    Copyright:    © 1994-1997 by Apple Computer, Inc., all rights reserved.
  12. //
  13. //    Change History (most recent first):
  14. //
  15. //       <12>         12/16/98    rtm        removed all QTVR API calls, so we can remove QTVR.lib from project
  16. //       <11>         11/14/97    rtm        begun adding QTMA support
  17. //       <10>         10/23/97    rtm        moved InitializeQTVR to InitApplication, TerminateQTVR to StopApplication
  18. //       <9>         10/13/97    rtm        reworked HandleApplicationMenu to use menu identifiers
  19. //       <8>         09/11/97    rtm        merged MacApplication.c and WinApplication.c into ComApplication.c
  20. //       <7>         08/21/97    rtm        first file for Windows; based on MacApplication.c for Mac sample code
  21. //       <6>         06/04/97    rtm        removed call to QTVRUtils_IsQTVRMovie in InitApplicationWindowObject
  22. //       <5>         02/06/97    rtm        fixed window resizing code
  23. //       <4>         12/05/96    rtm        added hooks into MacFramework.c: StopApplication, InitApplicationWindowObject
  24. //       <3>         12/02/96    rtm        added cursor updating to DoIdle
  25. //       <2>         11/27/96    rtm        conversion to personal coding style; added preliminary QTVR support
  26. //       <1>         12/21/94    khs        first file
  27. //       
  28. //////////
  29.  
  30. // header files
  31. #include "ComApplication.h"
  32. #include "QTMusic.h"
  33.  
  34. // global variables for Macintosh code
  35. #if TARGET_OS_MAC
  36. #endif
  37.  
  38. // global variables for Windows code
  39. #if TARGET_OS_WIN32
  40. extern HWND                ghWnd;                                    // the MDI frame window; this window has the menu bar
  41. extern int                gNumWindowsOpen;
  42. extern LPSTR            gCmdLine;
  43. #endif
  44.  
  45. long                    gMaxMilliSecToUse = 0L;        
  46.  
  47.  
  48. //////////
  49. //
  50. // InitApplication
  51. // Do any application-specific initialization.
  52. //
  53. // The theStartPhase parameter determines which "phase" of application start-up is executed,
  54. // *before* the MDI frame window is created or *after*. This distinction is relevant only on
  55. // Windows, so on MacOS, you should always use kInitAppPhase_BothPhases.
  56. //
  57. //////////
  58.  
  59. void InitApplication (UInt32 theStartPhase)
  60. {
  61.     // ***do any start-up activities that should occur before the MDI frame window is created
  62.     if (theStartPhase & kInitAppPhase_BeforeCreateFrameWindow) {
  63.  
  64.     }    // end of kInitAppPhase_BeforeCreateFrameWindow
  65.  
  66.     // ***do any start-up activities that should occur after the MDI frame window is created
  67.     if (theStartPhase & kInitAppPhase_AfterCreateFrameWindow) {
  68.         
  69. #if TARGET_OS_WIN32
  70.         // on Windows, open as movie documents any files specified on the command line
  71.         DoOpenCommandLineMovies(gCmdLine);                                    
  72. #endif
  73.  
  74.     }    // end of kInitAppPhase_AfterCreateFrameWindow
  75. }
  76.  
  77.  
  78. //////////
  79. //
  80. // StopApplication
  81. // Do any application-specific shut-down.
  82. //
  83. // The theStopPhase parameter determines which "phase" of application shut-down is executed,
  84. // *before* any open movie windows are destroyed or *after*.
  85. //
  86. //////////
  87.  
  88. void StopApplication (UInt32 theStopPhase)
  89. {
  90.  
  91. }
  92.  
  93.  
  94. //////////
  95. //
  96. // DoIdle
  97. // Do any processing that can/should occur at idle time.
  98. //
  99. //////////
  100.  
  101. void DoIdle (WindowReference theWindow)
  102. {
  103.     WindowObject         myWindowObject = NULL;
  104.     GrafPtr             mySavedPort;
  105.     
  106.     GetPort(&mySavedPort);
  107.     MacSetPort(GetPortFromWindowReference(theWindow));
  108.     
  109.     myWindowObject = GetWindowObjectFromWindow(theWindow);
  110.     if (myWindowObject != NULL) {
  111.         MovieController        myMC = NULL;
  112.     
  113.         myMC = (**myWindowObject).fController;
  114.         if (myMC != NULL) {
  115.  
  116. #if TARGET_OS_MAC
  117.             // restore the cursor to the arrow
  118.             // if it's outside the front movie window or outside the window's visible region
  119.             if (theWindow == GetFrontMovieWindow()) {
  120.                 Rect    myRect;
  121.                 Point    myPoint;
  122.                 
  123.                 GetMouse(&myPoint);
  124.                 MCGetControllerBoundsRect(myMC, &myRect);
  125.                 if (!MacPtInRect(myPoint, &myRect) || !PtInRgn(myPoint, GetPortFromWindowReference(theWindow)->visRgn))
  126.                     MacSetCursor(&qd.arrow);
  127.             }
  128. #endif    // TARGET_OS_MAC
  129.         }
  130.     }
  131.  
  132.     MacSetPort(mySavedPort);
  133. }
  134.  
  135.  
  136. //////////
  137. //
  138. // DoUpdateWindow
  139. // Update the specified window.
  140. //
  141. //////////
  142.  
  143. void DoUpdateWindow (WindowReference theWindow, Rect *theRefreshArea)
  144. {
  145.     GrafPtr             mySavedPort;
  146.     
  147.     GetPort(&mySavedPort);
  148.     MacSetPort(GetPortFromWindowReference(theWindow));
  149.     
  150.     BeginUpdate(GetPortFromWindowReference(theWindow));
  151.     
  152.     // draw the movie controller and its movie
  153.     MCDoAction(GetMCFromWindow(theWindow), mcActionDraw, theWindow);
  154.     
  155.     EndUpdate(GetPortFromWindowReference(theWindow));
  156.     MacSetPort(mySavedPort);
  157. }
  158.  
  159.  
  160. //////////
  161. //
  162. // HandleContentClick
  163. // Handle mouse button clicks in the specified window.
  164. //
  165. //////////
  166.  
  167. void HandleContentClick (WindowReference theWindow, EventRecord *theEvent)
  168. {
  169.     GrafPtr             mySavedPort;
  170.     
  171.     GetPort(&mySavedPort);
  172.     MacSetPort(GetPortFromWindowReference(theWindow));
  173.     
  174.     // @@@INSERT APPLICATION-SPECIFIC CONTENT CLICKING FUNCTIONALITY HERE
  175.  
  176.     MacSetPort(mySavedPort);
  177. }
  178.  
  179.  
  180. //////////
  181. //
  182. // HandleApplicationKeyPress
  183. // Handle application-specific key presses.
  184. // Returns true if the key press was handled, false otherwise.
  185. //
  186. //////////
  187.  
  188. Boolean HandleApplicationKeyPress (char theCharCode)
  189. {
  190.     Boolean        isHandled = true;
  191.     
  192.     switch (theCharCode) {
  193.     
  194.         // @@@HANDLE APPLICATION-SPECIFIC KEY PRESSES HERE
  195.  
  196.         default:
  197.             isHandled = false;
  198.             break;
  199.     }
  200.  
  201.     return(isHandled);
  202. }
  203.  
  204.  
  205. #if TARGET_OS_MAC
  206. //////////
  207. //
  208. // CreateMovieWindow
  209. // Create a window to display a movie in.
  210. //
  211. //////////
  212.  
  213. WindowRef CreateMovieWindow (Rect *theRect, Str255 theTitle)
  214. {
  215.     WindowRef            myWindow;
  216.         
  217.     myWindow = NewCWindow(NULL, theRect, theTitle, false, noGrowDocProc, (WindowPtr)-1L, true, 0);
  218.     return(myWindow);
  219. }
  220. #endif
  221.  
  222.  
  223. //////////
  224. //
  225. // HandleApplicationMenu
  226. // Handle selections in the application's menus.
  227. //
  228. // The theMenuItem parameter is a UInt16 version of the Windows "menu item identifier". 
  229. // When called from Windows, theMenuItem is simply the menu item identifier passed to the window proc.
  230. // When called from MacOS, theMenuItem is constructed like this:
  231. //     *high-order 8 bits == the Macintosh menu ID (1 thru 256)
  232. //     *low-order 8 bits == the Macintosh menu item (sequential from 1 to ordinal of last menu item in menu)
  233. // In this way, we can simplify the menu-handling code. There are, however, some limitations,
  234. // mainly that the menu item identifiers on Windows must be derived from the Mac values. 
  235. //
  236. //////////
  237.  
  238. void HandleApplicationMenu (UInt16 theMenuItem)
  239. {
  240.     WindowObject        myWindowObject = NULL;
  241.     MovieController     myMC = NULL;
  242.     
  243.     switch (theMenuItem) {
  244.     
  245.         case IDM_PLAY_SOME_NOTES:
  246.             QTMusic_PlaySomeNotes();
  247.             break;
  248.         
  249.         case IDM_PLAY_BENT_NOTES:
  250.             QTMusic_PlaySomeBentNotes();
  251.             break;
  252.         
  253.         case IDM_PLAY_SHEPARD_MELODY:
  254.             QTMusic_PlayShepardMelody();
  255.             break;
  256.         
  257.         case IDM_PICK_THEN_PLAY:
  258.             QTMusic_PickInstThenPlaySomeNotes();
  259.             break;
  260.         
  261.         case IDM_PICK_THEN_PLAY_CUSTOM:
  262.             QTMusic_PickCustomInstThenPlaySomeNotes();
  263.             break;
  264.         
  265.         case IDM_BUILD_AND_PLAY_SEQUENCE:
  266.             QTMusic_BuildSequenceAndPlay();
  267.             break;
  268.         
  269.         case IDM_BUILD_MUSIC_MOVIE:
  270.             QTMusic_CreateMusicMovie(NULL);
  271.             break;
  272.         
  273.         case IDM_BUILD_MUSIC_MOVIE_CUSTOM: {
  274.                 AtomicInstrument        myInstrument = NULL;
  275.                 Handle                    myHandle = NULL;
  276.             
  277.                 // open a file of type 'sfil' and get the single 'snd ' resource contained in it
  278.                 myHandle = QTMusic_PickSndResource();
  279.                 if (myHandle != NULL) {
  280.                     // create the new instrument from the resource data
  281.                     myInstrument = QTMusic_CreateAtomicInstFromResource(myHandle);
  282.                     if (myInstrument != NULL)
  283.                         QTMusic_CreateMusicMovie(myInstrument);
  284.                 }
  285.             }
  286.             break;
  287.         
  288.         case IDM_USE_MIDI_INPUT:
  289.             QTMusic_UseMIDIInput();
  290.             break;
  291.         
  292.         default:
  293.             break;
  294.     } // switch (theMenuItem)
  295. }
  296.  
  297.  
  298. //////////
  299. //
  300. // AdjustApplicationMenus
  301. // Adjust state of items in the application's menus.
  302. //
  303. //////////
  304.  
  305. void AdjustApplicationMenus (WindowReference theWindow, MenuReference theMenu)
  306. {
  307.     WindowObject        myWindowObject = NULL; 
  308.     MovieController     myMC = NULL;
  309.     MenuReference        myMenu;
  310.     
  311. #if TARGET_OS_WIN32
  312.     myMenu = theMenu;
  313. #elif TARGET_OS_MAC
  314.     myMenu = GetMenuHandle(kTestMenu);
  315. #endif
  316.     
  317.     if (theWindow != NULL)
  318.         myWindowObject = GetWindowObjectFromWindow(theWindow);
  319.  
  320.     if (myWindowObject != NULL)
  321.         myMC = (**myWindowObject).fController;
  322.  
  323.     // we don't allow creating new files here...
  324. #if TARGET_OS_MAC
  325.     SetMenuItemState(GetMenuHandle(mFile), iNew, kDisableMenuItem);
  326. #endif
  327.  
  328.     SetMenuItemState(myMenu, IDM_PLAY_SOME_NOTES, kEnableMenuItem);
  329.     SetMenuItemState(myMenu, IDM_PLAY_BENT_NOTES, kEnableMenuItem);
  330.     SetMenuItemState(myMenu, IDM_PLAY_SHEPARD_MELODY, kEnableMenuItem);
  331.     SetMenuItemState(myMenu, IDM_PICK_THEN_PLAY, kEnableMenuItem);
  332.     SetMenuItemState(myMenu, IDM_PICK_THEN_PLAY_CUSTOM, kEnableMenuItem);
  333.     SetMenuItemState(myMenu, IDM_BUILD_AND_PLAY_SEQUENCE, kEnableMenuItem);
  334.     SetMenuItemState(myMenu, IDM_BUILD_MUSIC_MOVIE, kEnableMenuItem);
  335.     SetMenuItemState(myMenu, IDM_BUILD_MUSIC_MOVIE_CUSTOM, kEnableMenuItem);
  336.     SetMenuItemState(myMenu, IDM_USE_MIDI_INPUT, kEnableMenuItem);
  337. }
  338.  
  339.  
  340. //////////
  341. //
  342. // DoApplicationEventLoopAction
  343. // Perform any application-specific event loop actions.
  344. //
  345. // Return true to indicate that we've completely handled the event here, false otherwise.
  346. //
  347. //////////
  348.  
  349. Boolean DoApplicationEventLoopAction (EventRecord *theEvent)
  350. {
  351.     return(false);            // no-op for now
  352. }
  353.  
  354.  
  355. //////////
  356. //
  357. // AddControllerFunctionality
  358. // Configure the movie controller.
  359. //
  360. //////////
  361.  
  362. void AddControllerFunctionality (MovieController theMC)
  363. {
  364.     long            myControllerFlags;
  365.     
  366.     // CLUT table use    
  367.     MCDoAction(theMC, mcActionGetFlags, &myControllerFlags);
  368.     MCDoAction(theMC, mcActionSetFlags, (void *)(myControllerFlags | mcFlagsUseWindowPalette));
  369.  
  370.     // enable keyboard event handling    
  371.     MCDoAction(theMC, mcActionSetKeysEnabled, (void *)true);
  372.     
  373.     // disable drag support
  374.     MCDoAction(theMC, mcActionSetDragEnabled, (void *)false);
  375. }
  376.  
  377.  
  378. //////////
  379. //
  380. // InitApplicationWindowObject
  381. // Do any application-specific initialization of the window object.
  382. //
  383. //////////
  384.  
  385. void InitApplicationWindowObject (WindowObject theWindowObject)
  386. {
  387. #pragma unused(theWindowObject)
  388.  
  389.     // @@@INSERT APPLICATION-SPECIFIC WINDOW OBJECT INITIALIZATION HERE
  390. }
  391.  
  392.  
  393. //////////
  394. //
  395. // RemoveApplicationWindowObject
  396. // Do any application-specific clean-up of the window object.
  397. //
  398. //////////
  399.  
  400. void RemoveApplicationWindowObject (WindowObject theWindowObject)
  401. {
  402. #pragma unused(theWindowObject)
  403.     
  404.     // @@@INSERT APPLICATION-SPECIFIC WINDOW OBJECT CLEAN-UP HERE
  405.  
  406.     // DoDestroyMovieWindow in MacFramework.c or MovieWndProc in WinFramework.c
  407.     // releases the window object itself
  408. }
  409.  
  410.  
  411. //////////
  412. //
  413. // ApplicationMCActionFilterProc 
  414. // Intercept some mc actions for the movie controller.
  415. //
  416. // NOTE: The theRefCon parameter is a handle to a window object record.
  417. //
  418. //////////
  419.  
  420. PASCAL_RTN Boolean ApplicationMCActionFilterProc (MovieController theMC, short theAction, void *theParams, long theRefCon)
  421. {
  422. #pragma unused(theMC, theParams)
  423.  
  424.     Boolean                isHandled = false;
  425.     WindowObject        myWindowObject = NULL;
  426.     
  427.     myWindowObject = (WindowObject)theRefCon;
  428.     if (myWindowObject == NULL)
  429.         return(isHandled);
  430.         
  431.     switch (theAction) {
  432.     
  433.         // handle window resizing
  434.         case mcActionControllerSizeChanged:
  435.             SizeWindowToMovie(myWindowObject);
  436.             break;
  437.  
  438.         // handle idle events
  439.         case mcActionIdle:
  440.             DoIdle((**myWindowObject).fWindow);
  441.             break;
  442.             
  443.         default:
  444.             break;
  445.             
  446.     }    // switch (theAction)
  447.     
  448.     return(isHandled);    
  449. }
  450.  
  451.  
  452.